home *** CD-ROM | disk | FTP | other *** search
/ The Atari Compendium / The Atari Compendium (Toad Computers) (1994).iso / files / prgtools / mint / filesy~1 / mfs610s.zoo / minixfs / zone.c < prev   
Encoding:
C/C++ Source or Header  |  1994-04-19  |  15.4 KB  |  636 lines
  1. /* This file is part of 'minixfs' Copyright 1991,1992,1993 S.N. Henson */
  2.  
  3. #include "minixfs.h"
  4. #include "proto.h"
  5. #include "global.h"
  6.  
  7. int read_zone(num,buf,drive,control)
  8. long num ;
  9. void *buf;
  10. int drive;
  11. cache_control *control;
  12. {
  13.     if(num) bcopy(cget_block(num,drive,control),buf,(size_t)BLOCK_SIZE);
  14.     else bzero(buf,(size_t)BLOCK_SIZE);
  15.     return(0);
  16. }
  17.  
  18. /* Only ever used for directories so always syscache */
  19. bufr *get_zone(num,drive)
  20. long num ;
  21. int drive;
  22. {
  23.     return(cget_block(num,drive,&syscache));
  24. }
  25.  
  26. /* Zone cache stuff (same as cache stuff but with checking) */
  27. cache *cget_zone(num,drive,control,guess)
  28. long num;
  29. int drive;
  30. cache_control *control;
  31. cache **guess;
  32. {
  33.     return (cache_get(num,drive,control,guess));
  34. }
  35.  
  36. cache *cput_zone(num,drive,control)
  37. long num;
  38. int drive;
  39. cache_control *control;
  40. {
  41.     return (cache_put(num,drive,control));
  42. }
  43.  
  44. int write_zone(num,buf,drive,control)
  45. long num ;
  46. void *buf;
  47. int drive;
  48. cache_control *control;
  49. {
  50.     cput_block(num,drive,buf,control);
  51.     return(0);
  52. }
  53.  
  54. /* This is a 'clever' write_zone which recognises consecutive blocks and
  55.  * queues requests until it gets one out of sequence.This allows large
  56.  * i/o requests to be done with a single Rwabs for consecutive blocks
  57.  * which is much faster than lots of little ones.
  58.  */
  59.  
  60. int write_zones(num,buf,drive,control)
  61. long num;
  62. void *buf;
  63. int drive;
  64. cache_control *control;
  65. {
  66.     static void *qstart,*qnext;
  67.     static long nstart,nnext,count;
  68.     static short qdrive=-1;
  69.     cache *p;
  70.     int i;
  71.  
  72.     if(drive != -1 && (p=in_cache(num,drive,control,NOGUESS)) )
  73.     {
  74.         bcopy(buf,p->buffer,(size_t)BLOCK_SIZE);
  75.         p->status=1;
  76.     }
  77.  
  78.     if(buf!=qnext || nnext!=num || qdrive!=drive || count > MAX_RWS )
  79.     {
  80.         /* Flush out queue */
  81.         if(qdrive!=-1) 
  82.         {
  83.         chk_zone(nstart,count,drive);
  84.         if(count<8) for(i=0;i<count;i++) 
  85.             write_zone(nstart+i,qstart+(i<<L_BS),qdrive,control);
  86.         else crwabs(3,qstart,count,nstart,qdrive);
  87.         }
  88.         qdrive=drive;
  89.         qstart=buf;
  90.         qnext=buf+BLOCK_SIZE;
  91.         nstart=num;
  92.         nnext=num+1;
  93.         count=1;
  94.     }
  95.     else 
  96.     {
  97.         qnext+=BLOCK_SIZE;
  98.         count++;
  99.         nnext++;
  100.     }
  101.     return 0;
  102. }
  103.  
  104. /* This is an equivalent for read ... but this is a bit harder as it is
  105.  * not obvious what to do with the cache . What we finally do is to
  106.  * always get data from the cache if we can , though this could easily
  107.  * turn a large consecutive i/o request into lots of little ones . The
  108.  * cache is not filled from the new read unless we are only reading
  109.  * 1 zone ... basically this assumes that if the user reads several zones
  110.  * then the program will be doing doing some sort of cacheing itself .
  111.  */
  112.  
  113. int read_zones(num,buf,drive,control)
  114. long num;
  115. void *buf;
  116. int drive;
  117. cache_control *control;
  118. {
  119.     static void *qstart,*qnext;
  120.     static long nstart,nnext,count;
  121.     static short qdrive=-1;
  122.     cache *p;
  123.     /* Read from cache if necessary */
  124.  
  125.     if(drive != -1 && (p=in_cache(num,drive,control,NOGUESS)) )
  126.     {
  127.         bcopy(p->buffer,buf,(size_t)BLOCK_SIZE);
  128.         drive=-1; /* Force flush of queued entries */
  129.     }
  130.  
  131.     if( qdrive!=drive || buf!=qnext || nnext!=num || (count > MAX_RWS) )
  132.     {
  133.         /* Flush out queue */
  134.         if(qdrive!=-1)
  135.         {
  136.             if(count==1) read_zone(nstart,qstart,qdrive,control);
  137.             else {
  138.                 if(nnext) crwabs(2,qstart,count,nstart,qdrive);
  139.                 else bzero(qstart,count*(size_t)BLOCK_SIZE);
  140.             }
  141.         }
  142.         qdrive=drive;
  143.         qstart=buf;
  144.         qnext=buf;
  145.         nstart=num;
  146.         nnext=num;
  147.         count=0;
  148.     }
  149.     if(qdrive!=-1)
  150.     {
  151.         qnext+=BLOCK_SIZE;
  152.         count++;
  153.         if(nnext)nnext++;
  154.     }
  155.     return 0;
  156. }
  157.  
  158. /* This routine finds the zone 'numr' of an inode , traversing indirect
  159.  * and double indirect zones as required if flag!=0 zones are added as
  160.  * required . Having two filesystem versions makes this a bit trickier, in
  161.  * fact although using a single routine looks more elegant it is slow,
  162.  * so two versions are used.
  163.  */
  164. /* Special case for l_write:
  165.    if flag > 1, and a new zone is allocated, prepare a cleared block.
  166.    This is for writing to sparse files, when only a partial block is
  167.    written, the rest must be cleared.  Since directories are never
  168.    sparse, always use usrcache in this case. */
  169.  
  170. long find_zone(rip,numr,drive,flag)
  171. d_inode *rip;
  172. long numr;
  173. int drive;
  174. int flag;
  175. {
  176.     super_info *psblk=super_ptr[drive];
  177.  
  178.     return psblk->version ? find_zone2(rip,numr,drive,flag,&dummy) : 
  179.                     find_zone1(rip,numr,drive,flag);
  180. }
  181.  
  182. long find_zone11(rip,numr,drive,flag,fch)
  183. d_inode1 *rip;
  184. long numr;
  185. int drive;
  186. int flag;
  187. f_cache *fch;
  188. {
  189.     long temp_zone;
  190.     unshort *zptr,*zptr2;
  191.     cache *tmp,*tmp2;
  192.  
  193.     /* Past EOF ? */
  194.     if(!flag && (numr*BLOCK_SIZE >= rip->i_size) ) return(0);
  195.  
  196.     /* Zone in inode ? */
  197.     if(numr < NR_DZONE_NUM)
  198.     {
  199.         temp_zone=rip->i_zone[numr];
  200.         if(temp_zone || !flag ) return temp_zone;
  201.         temp_zone = (rip->i_zone[numr]=alloc_zone(drive));
  202.         goto new_zone;
  203.     }
  204.     numr-=NR_DZONE_NUM;
  205.     /* In indirect zone then ? */
  206.     if(numr < NR_INDIRECTS)
  207.     {
  208.         if(rip->i_zone[7])
  209.         {
  210.             tmp=
  211.             cget_zone(rip->i_zone[7],drive,&syscache,&fch->izguess);
  212.             zptr=&tmp->buffer->bind1[numr];
  213.             if( *zptr || !flag )return *zptr;
  214.             if( (*zptr=alloc_zone(drive)) ) tmp->status=2;
  215.             temp_zone = *zptr;
  216.             goto new_zone;
  217.         }
  218.         else
  219.         {
  220.             if(!flag || !(rip->i_zone[7]=alloc_zone(drive))) return 0;
  221.             tmp=cput_zone(rip->i_zone[7],drive,&syscache);
  222.             fch->izguess=tmp;
  223.             bzero(tmp->buffer,(size_t)BLOCK_SIZE);
  224.             temp_zone = tmp->buffer->bind1[numr]=alloc_zone(drive);
  225.             goto new_zone;
  226.         }
  227.     }
  228.     /* Erk double indirect .... */
  229.     numr-=NR_INDIRECTS;
  230.     if (numr < NR_INDIRECTS * NR_INDIRECTS)
  231.     {
  232.  
  233.             if(rip->i_zone[8]) {
  234.         tmp2=cget_zone(rip->i_zone[8],drive,&syscache,&fch->dizguess);
  235.             zptr2=&tmp2->buffer->bind1[numr>>LNR_IND];
  236.             if(*zptr2)
  237.             {
  238.                  tmp=cget_zone(*zptr2,drive,&syscache,&fch->izguess);
  239.                 zptr=&tmp->buffer->bind1[numr & (NR_INDIRECTS-1)];
  240.                 if(*zptr || !flag)return *zptr;
  241.                 if( (*zptr=alloc_zone(drive)) ) tmp->status=2;
  242.                 temp_zone = *zptr;
  243.                 goto new_zone;
  244.               }
  245.               else 
  246.               {
  247.                      if(!flag ||!(*zptr2=alloc_zone(drive)) )return 0;
  248.                 tmp2->status=2;
  249.                 tmp=cput_zone(*zptr2,drive,&syscache);
  250.                 fch->izguess=tmp;
  251.                      bzero(tmp->buffer,(size_t)BLOCK_SIZE);
  252.                 zptr=&tmp->buffer->bind1[numr & (NR_INDIRECTS-1)];
  253.                 temp_zone = *zptr=alloc_zone(drive);
  254.                 goto new_zone;
  255.               }
  256.         }
  257.         if(!flag || !(rip->i_zone[8]=alloc_zone(drive)) ) return 0;
  258.     
  259.         tmp2=cput_zone(rip->i_zone[8],drive,&syscache);
  260.         fch->dizguess=tmp2;
  261.         bzero(tmp2->buffer,(size_t)BLOCK_SIZE);
  262.         zptr2=&tmp2->buffer->bind1[numr>>LNR_IND];
  263.         if(!(*zptr2=alloc_zone(drive))) return 0;
  264.  
  265.         tmp=cput_zone(*zptr2,drive,&syscache);
  266.         fch->izguess=tmp;
  267.         bzero(tmp->buffer,(size_t)BLOCK_SIZE);
  268.         zptr=&tmp->buffer->bind1[numr & (NR_INDIRECTS-1)];
  269.         temp_zone = *zptr=alloc_zone(drive) ;
  270.         goto new_zone;
  271.     }
  272.     return 0;
  273.  
  274.       new_zone:
  275.     if (temp_zone && flag > 1)
  276.       {
  277.         tmp = cput_zone (temp_zone, drive, &usrcache);
  278.         bzero (tmp->buffer, (size_t) BLOCK_SIZE);
  279.       }
  280.     return temp_zone;
  281. }
  282.  
  283. long find_zone1(rip,numr,drive,flag)
  284. d_inode *rip;
  285. long numr;
  286. int drive;
  287. int flag;
  288. {
  289.     long temp_zone;
  290.     unshort *zptr,*zptr2;
  291.     cache *tmp,*tmp2;
  292.  
  293.     /* Past EOF ? */
  294.     if(!flag && (numr*BLOCK_SIZE >= rip->i_size) ) return(0);
  295.  
  296.     /* Zone in inode ? */
  297.     if(numr < NR_DZONE_NUM)
  298.     {
  299.         temp_zone=rip->i_zone[numr];
  300.         if(temp_zone || !flag ) return temp_zone;
  301.         return(rip->i_zone[numr]=alloc_zone(drive));
  302.     }
  303.     numr-=NR_DZONE_NUM;
  304.     /* In indirect zone then ? */
  305.     if(numr < NR_INDIRECTS)
  306.     {
  307.         if(rip->i_zone[7])
  308.         {
  309.             tmp=cget_zone(rip->i_zone[7],drive,&syscache,NOGUESS);
  310.             zptr=&tmp->buffer->bind1[numr];
  311.             if( *zptr || !flag )return *zptr;
  312.             if( (*zptr=alloc_zone(drive)) ) tmp->status=2;
  313.             return *zptr;
  314.         }
  315.         else
  316.         {
  317.             if(!flag || !(rip->i_zone[7]=alloc_zone(drive))) return 0;
  318.             tmp=cput_zone(rip->i_zone[7],drive,&syscache);
  319.             bzero(tmp->buffer,(size_t)BLOCK_SIZE);
  320.             return tmp->buffer->bind1[numr]=alloc_zone(drive);
  321.         }
  322.     }
  323.     /* Erk double indirect .... */
  324.     numr-=NR_INDIRECTS;
  325.     if (numr < NR_INDIRECTS * NR_INDIRECTS)
  326.     {
  327.  
  328.             if(rip->i_zone[8]) {
  329.             tmp2=cget_zone(rip->i_zone[8],drive,&syscache,NOGUESS);
  330.             zptr2=&tmp2->buffer->bind1[numr>>LNR_IND];
  331.             if(*zptr2)
  332.             {
  333.                      tmp=cget_zone(*zptr2,drive,&syscache,NOGUESS);
  334.                 zptr=&tmp->buffer->bind1[numr & (NR_INDIRECTS-1)];
  335.                 if(*zptr || !flag)return *zptr;
  336.                 if( (*zptr=alloc_zone(drive)) ) tmp->status=2;
  337.                 return *zptr;
  338.               }
  339.               else 
  340.               {
  341.                      if(!flag ||!(*zptr2=alloc_zone(drive)) )return 0;
  342.                 tmp2->status=2;
  343.                 tmp=cput_zone(*zptr2,drive,&syscache);
  344.                      bzero(tmp->buffer,(size_t)BLOCK_SIZE);
  345.                 zptr=&tmp->buffer->bind1[numr & (NR_INDIRECTS-1)];
  346.                 return *zptr=alloc_zone(drive);
  347.               }
  348.         }
  349.         if(!flag || !(rip->i_zone[8]=alloc_zone(drive)) ) return 0;
  350.     
  351.         tmp2=cput_zone(rip->i_zone[8],drive,&syscache);
  352.         bzero(tmp2->buffer,(size_t)BLOCK_SIZE);
  353.         zptr2=&tmp2->buffer->bind1[numr>>LNR_IND];
  354.         if(!(*zptr2=alloc_zone(drive))) return 0;
  355.  
  356.         tmp=cput_zone(*zptr2,drive,&syscache);
  357.         bzero(tmp->buffer,(size_t)BLOCK_SIZE);
  358.         zptr=&tmp->buffer->bind1[numr & (NR_INDIRECTS-1)];
  359.         return *zptr=alloc_zone(drive) ;
  360.     }
  361.     return 0;
  362. }
  363.  
  364. long find_zone2(rip,numr,drive,flag,fch)
  365. d_inode *rip;
  366. long numr;
  367. int drive;
  368. int flag;
  369. f_cache *fch;
  370. {
  371.     long temp_zone;
  372.     long *zptr,*zptr2;
  373.     cache *tmp,*tmp2;
  374.  
  375.     /* Past EOF ? */
  376.     if((numr*BLOCK_SIZE >= rip->i_size) && !flag ) return(0);
  377.  
  378.     /* Zone in inode ? */
  379.     if(numr < NR_DZONE_NUM2)
  380.     {
  381.         temp_zone=rip->i_zone[numr];
  382.         if(temp_zone || !flag ) return temp_zone;
  383.         temp_zone = (rip->i_zone[numr]=alloc_zone(drive));
  384.         goto new_zone;
  385.     }
  386.     numr-=NR_DZONE_NUM2;
  387.     /* In indirect zone then ? */
  388.     if(numr < NR_INDIRECTS2)
  389.     {
  390.         if(rip->i_zone[7])
  391.         {
  392.             tmp=
  393.             cget_zone(rip->i_zone[7],drive,&syscache,&fch->izguess);
  394.             zptr=&tmp->buffer->bind[numr];
  395.             if( *zptr || !flag )return *zptr;
  396.             if( (*zptr=alloc_zone(drive)) ) tmp->status=2;
  397.             temp_zone = *zptr;
  398.             goto new_zone;
  399.         }
  400.         else
  401.         {
  402.             if(!flag || !(rip->i_zone[7]=alloc_zone(drive))) return 0;
  403.             tmp=cput_zone(rip->i_zone[7],drive,&syscache);
  404.             bzero(tmp->buffer,(size_t)BLOCK_SIZE);
  405.             temp_zone = tmp->buffer->bind[numr]=alloc_zone(drive);
  406.             goto new_zone;
  407.         }
  408.     }
  409.     /* Erk double indirect .... */
  410.     numr-=NR_INDIRECTS2;
  411.     if (numr < NR_INDIRECTS2 * NR_INDIRECTS2)
  412.     {
  413.         if(rip->i_zone[8]) {
  414.           tmp2=cget_zone(rip->i_zone[8],drive,&syscache,&fch->dizguess);
  415.             zptr2=&tmp2->buffer->bind[numr>>LNR_IND2];
  416.             if(*zptr2)
  417.             {
  418.                      tmp=
  419.                 cget_zone(*zptr2,drive,&syscache,&fch->izguess);
  420.                 zptr=&tmp->buffer->bind[numr & (NR_INDIRECTS2-1)];
  421.                 if(*zptr || !flag)return *zptr;
  422.                 if( (*zptr=alloc_zone(drive)) ) tmp->status=2;
  423.                 temp_zone = *zptr;
  424.                 goto new_zone;
  425.               }
  426.               else 
  427.               {
  428.                      if(!flag ||!(*zptr2=alloc_zone(drive)) )return 0;
  429.                 tmp2->status=2;
  430.                 tmp=cput_zone(*zptr2,drive,&syscache);
  431.                      bzero(tmp->buffer,(size_t)BLOCK_SIZE);
  432.                 zptr=&tmp->buffer->bind[numr & (NR_INDIRECTS2-1)];
  433.                 temp_zone = *zptr=alloc_zone(drive);
  434.                 goto new_zone;
  435.               }
  436.         }
  437.         if(!flag || !(rip->i_zone[8]=alloc_zone(drive)) ) return 0;
  438.     
  439.         tmp2=cput_zone(rip->i_zone[8],drive,&syscache);
  440.         bzero(tmp2->buffer,(size_t)BLOCK_SIZE);
  441.         zptr2=&tmp2->buffer->bind[numr>>LNR_IND2];
  442.         if(!(*zptr2=alloc_zone(drive))) return 0;
  443.  
  444.         tmp=cput_zone(*zptr2,drive,&syscache);
  445.         bzero(tmp->buffer,(size_t)BLOCK_SIZE);
  446.         zptr=&tmp->buffer->bind[numr & (NR_INDIRECTS2-1)];
  447.         temp_zone = *zptr=alloc_zone(drive) ;
  448.         goto new_zone;
  449.     }
  450.     return 0;
  451.  
  452.       new_zone:
  453.     if (temp_zone && flag > 1)
  454.       {
  455.         tmp = cput_zone (temp_zone, drive, &usrcache);
  456.         bzero (tmp->buffer, (size_t) BLOCK_SIZE);
  457.       }
  458.     return temp_zone;
  459. }
  460.  
  461. /* This reads zone number 'numr' of an inode .
  462.  * It returns the actual number of valid characters in 'numr' , this is only
  463.  * used for directories so it is hard-coded for the system cache. 
  464.  */
  465.  
  466. int next_zone(rip,numr,buf,drive)
  467. d_inode *rip;
  468. long numr;
  469. void *buf;
  470. int drive;
  471. {
  472.     long ztemp;
  473.     long ret;
  474.  
  475.     ret=min(rip->i_size-numr*BLOCK_SIZE,BLOCK_SIZE);
  476.     if(ret <= 0)return 0;
  477.     ztemp=find_zone(rip,numr,drive,0);
  478.     read_zone(ztemp,buf,drive,&syscache);
  479.     return (int)ret;
  480. }
  481.  
  482. /* As above but reads in cache pointer */
  483.  
  484. int cnext_zone(rip,numr,buf,drive)
  485. d_inode *rip;
  486. long numr;
  487. cache **buf;
  488. int drive;
  489. {
  490.     long ztemp;
  491.     long ret;
  492.  
  493.     ret=min(rip->i_size-numr*BLOCK_SIZE,BLOCK_SIZE);
  494.     if(ret <= 0)return 0;
  495.     ztemp=find_zone(rip,numr,drive,0);
  496.     *buf=cget_zone(ztemp,drive,&syscache,NOGUESS);
  497.     return (int)ret;
  498. }
  499.  
  500. /* l_write is used internally for doing things a normal user cannot such
  501.  * as writing to a directory ... it accepts 5 parameters , an inode num
  502.  * a position (current position of write) a count which is the number of
  503.  * characters to write,a buffer and a drive , it updates i_size as needed 
  504.  * and allocates zones as required , it is nastier than a read because it 
  505.  * has to write partial blocks within valid blocks and to write beyond EOF
  506.  */
  507.  
  508. long l_write(inum,pos,len,buf,drive)
  509. unsigned inum;
  510. long pos;
  511. long len;
  512. const void *buf;
  513. int drive;
  514. {
  515.     return super_ptr[drive]->version ? l_write2(inum,pos,len,buf,drive) :
  516.                     l_write1(inum,pos,len,buf,drive);
  517. }
  518.  
  519. long l_write1(inum,pos,len,buf,drive)
  520. unsigned inum;
  521. long pos;
  522. long len;
  523. const void *buf;
  524. int drive;
  525. {
  526.     register const void *p = buf;    /* Current position in buffer */
  527.     d_inode1 *rip;
  528.     long chunk;
  529.     long left=len;
  530.     long zne;
  531.     cache_control *control;
  532.     int *status;
  533.  
  534.     rip=get_inode1(inum,drive,&status,NOGUESS);
  535.  
  536.      /* Work out which cache to use */
  537.     control = IS_DIR((*rip)) ? &syscache : &usrcache;
  538.     if(pos==-1l) pos=rip->i_size; /* If pos==-1 append */
  539.     chunk=pos/BLOCK_SIZE;
  540.  
  541.     while(left)    /* Loop while characters remain to be written */
  542.     {
  543.     long zoff;
  544.     ushort wleft;
  545.     cache *cp;
  546.  
  547.     zoff = pos & (BLOCK_SIZE -1);        /* Current zone position */
  548.     wleft=min(BLOCK_SIZE-zoff,left);    /*Left to write in curr blk*/    
  549.     zne = find_zone11 (rip, chunk++, drive,
  550.                1 + (zoff || pos < rip->i_size),
  551.                &dummy); /* Current zone in file */
  552.     if(zne==0) break;            /* Partition full */
  553.  
  554.     if((zoff) || ( (left < BLOCK_SIZE) && (pos+left<rip->i_size)))
  555.     {
  556.         cp=cget_zone(zne,drive,control,NOGUESS);
  557.         cp->status=2;
  558.     }
  559.     else 
  560.     {
  561.         cp=cput_zone(zne,drive,control);
  562.         if(wleft!=BLOCK_SIZE)bzero(cp->buffer->bdata,(size_t)BLOCK_SIZE);
  563.     }
  564.     bcopy(p,&cp->buffer->bdata[zoff],(size_t)wleft);
  565.     pos+=wleft;
  566.     p+=wleft;
  567.     if(pos>rip->i_size)rip->i_size=pos;
  568.     left-=wleft;
  569.     }
  570.  
  571.     rip->i_mtime=Unixtime(Timestamp(), Datestamp());
  572.     *status=2;
  573.  
  574.     return(len-left);
  575. }
  576.  
  577. long l_write2(inum,pos,len,buf,drive)
  578. unsigned inum;
  579. long pos;
  580. long len;
  581. const void *buf;
  582. int drive;
  583. {
  584.     register const void *p = buf;    /* Current position in buffer */
  585.     d_inode *rip;
  586.     long chunk;
  587.     long left=len;
  588.     long zne;
  589.     cache_control *control;
  590.     int *status;
  591.  
  592.     rip=get_inode2(inum,drive,&status,NOGUESS);
  593.  
  594.      /* Work out which cache to use */
  595.     control = IS_DIR((*rip)) ? &syscache : &usrcache;
  596.     if(pos==-1l) pos=rip->i_size; /* If pos==-1 append */
  597.     chunk=pos/BLOCK_SIZE;
  598.  
  599.     while(left)    /* Loop while characters remain to be written */
  600.     {
  601.     long zoff;
  602.     ushort wleft;
  603.     cache *cp;
  604.  
  605.     zoff = pos & (BLOCK_SIZE -1);        /* Current zone position */
  606.     wleft=min(BLOCK_SIZE-zoff,left);    /*Left to write in curr blk*/    
  607.  
  608.     if((zoff) || ( (left < BLOCK_SIZE) && (pos+left<rip->i_size)))
  609.     {
  610.         zne = find_zone2 (rip, chunk++, drive, 2,
  611.                   &dummy); /* Current zone in file */
  612.         if(zne==0)break;            /* Partition full */
  613.         cp=cget_zone(zne,drive,control,NOGUESS);
  614.         cp->status=2;
  615.     }
  616.     else 
  617.     {
  618.         zne = find_zone2 (rip, chunk++, drive, 1,
  619.                   &dummy); /* Current zone in file */
  620.         if(zne==0)break;            /* Partition full */
  621.         cp=cput_zone(zne,drive,control);
  622.         if(wleft!=BLOCK_SIZE)bzero(cp->buffer->bdata,(size_t)BLOCK_SIZE);
  623.     }
  624.     bcopy(p,&cp->buffer->bdata[zoff],(size_t)wleft);
  625.     pos+=wleft;
  626.     p+=wleft;
  627.     if(pos>rip->i_size)rip->i_size=pos;
  628.     left-=wleft;
  629.     }
  630.  
  631.     rip->i_mtime=Unixtime(Timestamp(), Datestamp());
  632.     *status=2;
  633.  
  634.     return(len-left);
  635. }
  636.